package com.student.xujiang.myallstudent.rxjava;

import android.util.Log;

import java.util.concurrent.TimeUnit;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * Created by xujiang on 2017/3/20.
 */

public class RxUtils {
    private static final String TAG= RxUtils.class.getSimpleName();

    /**
     * RxJava最核心的两个东西是Observables（被观察者，事件源）和Subscribers（观察者）。
     * Observables发出一系列事件，Subscribers处理这些事件。
     * 这里的事件可以是任何你感兴趣的东西（触摸事件，web接口调用返回的数据。。。）
     *http://blog.csdn.net/lzyzsd/article/details/41833541
     * */
    public static void createObserable(){
        //定义被观察者
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                if(!subscriber.isUnsubscribed()){
                    subscriber.onNext("Hello");
                    subscriber.onNext("hi");
                    subscriber.onNext(downLoadJson());
                    subscriber.onNext("world");
                    subscriber.onCompleted();
                }
            }
        });

        //观察者 ，用于接受数据
        Subscriber<String> showSub = new Subscriber<String>(){

            @Override
            public void onCompleted() {
                Log.i(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG,"onError"+e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG,"onNext:"+s);

            }
        };

        observable.subscribe(showSub);  //关联被观察者
    }

    private static String downLoadJson() {
        return "json data";
    }

    /**
    * create的第二种方式
    *
    * */
    public static void createPrint(){
        Observable.create(new Observable.OnSubscribe<Integer>(){

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if(!subscriber.isUnsubscribed()){
                    for (int i=1;i<=10;i++){
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                }
            }
        }).subscribe(new Subscriber<Integer>() {

            @Override
            public void onCompleted() {
                Log.i(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG,"onError"+e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.i(TAG,"onNext:"+integer);
            }
        });
    }

    /**
    * 使用在被观察者，返回的对象一般都是数值类型
    * */
    public static void from(){
        Integer[] items = {1,2,3,4,5,6,7,8,9};
        Observable observable = Observable.from(items);
        /**
         * 接下来看看如何简化Subscriber，上面的例子中，
         * 我们其实并不关心OnComplete和OnError，
         * 我们只需要在onNext的时候做一些处理，这时候就可以使用Action1类。
         *
         * */
        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i(TAG,o.toString());
            }
        });
    }

        /*
    * 指定某一时刻进行数据发送
    * */

    public static void interval(){
        Integer[] items = {1,2,3,4,5};
        Observable observable = Observable.interval(1,1, TimeUnit.SECONDS); //每隔一秒发送一个数据
        observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i(TAG,o.toString());
            }
        });
    }

    /**
   * 处理数组类型
     * 可以只传一个
     * 直传一次全部传过去
   * */
    public static void just(){
        Integer[] items1 = {1,3,5,7,9,11};
        Integer[] items2 = {2,4,6,8,10,12};
        Observable observable = Observable.just(items1,items2);
        observable.subscribe(new Subscriber<Integer[]>() {
            @Override
            public void onCompleted() {
                Log.i(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG,"onError"+e.getMessage());
            }

            @Override
            public void onNext(Integer[] integers) {
                for(int i=0;i<integers.length;i++){
                    Log.i(TAG,"onNext:"+integers[i].toString());
                }

            }
        });
    }

    /**
    * 输出某个范围的值
    * */
    public static void range(){
        Observable observable = Observable.range(1,40);
        observable.subscribe(new Subscriber<Integer>(){

            @Override
            public void onCompleted() {
                Log.i(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG,"onError"+e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.i(TAG,"onNext:"+integer.toString());
            }
        });
    }


    /**
    * 过滤某些条件
    * */
    public static void filter(){
        Observable observable = Observable.just(1,2,3,4,5,6,7,8);
        observable.filter(new Func1<Integer,Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer<5;
            }
        }).observeOn(Schedulers.io())
                .subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.i(TAG,"onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG,"onError"+e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.i(TAG,integer.toString());
            }


        });
    }


    //操作符（Operators）public
    /**
     *操作符就是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件。RxJava提供了很多很有用的操作符。
     比如map操作符，就是用来把把一个事件转换为另一个事件的。
     *
     * */

    public static void map(){
        Observable.just("Hello,world")
                .map(new Func1<String,String>() {
                    @Override
                    public String call(String s) {
                        return s+"---xujiang";
                    }
                }).subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.i(TAG,"onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                       Log.i(TAG,e.getLocalizedMessage());
                    }

                    @Override
                    public void onNext(String s) {
                        Log.i(TAG,s);
                    }
                });



    }





}
